%% main.tex --- файл-обертка для диплома

\documentclass[russian,utf8,simple,floatsection]{eskdtext} 

\include{defs}  % вставляем содержимое служебных инструкций из defs.tex

\ESKDcolumnII{Заключение}

\begin{document}
\section*{Заключение}
\addcontentsline{toc}{section}{Заключение}
В данной работе разработанно  программное обеспечение для
прогнозирования величины потребления воды население города для
городского водоканала.

Данный программный продукт полностью удовлетворяет требованиям,
предъявленным к проектируемой системе и описанным в техническом
задании на разработку продукта.

В результате разработки программного обеспечения, решены следующие
задачи:
\begin{itemize}
\item Обоснованна актуальность темы. 
\item Проведен анализ существующих систем.
\item Разработана модульная структура ПО.
\item Составлена диаграмма классов.
\item Разработан пользовательский интерфейс.
\item Разработана диаграмма базы данных. 
\item Проведен расчет показателей экономической эффективности.
\item Выполнена программная реализация продукта.
\end{itemize}

\clearpage
\section*{Список литературы}
\addcontentsline{toc}{section}{Список литературы}
1.Методические указания к выполнению квалификационной работы для
студентов специальности 220400 – Программное обеспечение
вычислительной техники и автоматизированных систем / Составители:
Константинов И.С., Полунин А.И., Титаренко С.П., рецензент: Подлесный
В. Н., 2005. – 50 с.

2.Информатика и информационные технологии. Учебник /
Н. Д. Угринович. – 2-е изд. – М.: БИНОМ. Лаборатория знаний, 2005. –
511с.: ил. 

3.Системы поддержки принятия решений: основные понятия и вопросы
применения / Синюк В.Г., Котельников А.П. - учебное пособие. –
Белгород: Изд-во БелГТАСМ, 1998. – 78с.

4.Технология разработки программного обеспечения: Методические
указания. / Румбешт В.В. - Белгород: Изд-во БелГТАСМ, 2000. - 42 с.

5.Базы данных. Проектирование, реализация и сопровождение. Теория и
практика. / Т. Коннолли, К. Бегг. 3-е издание.: Пер. с англ. – М.:
Издательский дом «Вильямс», 2003. – 1440 с.: ил. – Парал. тит. англ.

6. Принятие решений. Метод анализа иерархий / Т. Саати – Москва «Радио
и связь», 1993. – 278с.

7. MySQL.RU .:. Одобрено лучшими российскими программистами /
http://www.mysql.ru.

\clearpage
\section*{Приложение}
\addcontentsline{toc}{section}{Приложение}

%\textbf{ga_test.py}
\begin{lstlisting}[language=python]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy
import numpy.linalg as linalg
import math

import ga.population
import ga.population_init
import ga.std_selector
import ga.arithmetic_crv
import ga.std_mutator
import ga.std_ga


#import ga.c_ftns.summ

def ftn(d):
    return abs(numpy.sum(d))

psize=50
pinit=ga.population_init.PopulationInit(2000*3,(-10,10))
m=ga.std_mutator.Mutator(delta=0.5,percent=100,count=2)
s=ga.std_selector.selector(int(psize/2))
p=ga.population.Population(crossover=ga.arithmetic_crv.crossover,
                           mutator=m,
                           pinit=pinit,
                           selector=s,
                           fitness=ftn,
                           psize=psize,
                           is_elit=True)


ga=ga.std_ga.GA(p,0.001,1000)
ga.run()


\end{lstlisting}
%\textbf{sugeno0.py}
\begin{lstlisting}[language=python]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import numpy

import fuzzy.function

if len(sys.argv)!=2:
    print "usage:",sys.argv[0],"path_to_file.csv"
    sys.exit(1)

data=[]
data_file=file(sys.argv[1])

for line in data_file.readlines():
    sl=line.split(';')
    il=[]
    for s in sl:
        s=s.strip()
        if s=='':
            continue
        il.append(float(s))
    if len(il)==0:
        continue
    data.append(il)

print data
x_length=len(data[0])-1
min_x=data[0]
max_x=data[0]
min_y=data[0][-1]
max_y=data[0][-1]

numbers=range(len(data)) 

for str in range(len(data)):
    for i in range(0,x_length):
        if max_x[i]<data[str][i]:
            max_x[i]=data[str][i]
        elif min_x[i]>data[str][i]:
            min_x[i]=data[str][i]

for str in range(len(data)):
    if max_y<data[str][-1]:
        max_y=data[str][-1]
    elif min_y>data[str][-1]:
        min_y=data[str][-1]

y_function=fuzzy.function.PointFunc([(min_y,0),
                                     ((min_y+max_y)/2.0,0.5),
                                     (max_y,1.0)])
x_functions=[]
for i in range(x_length):
    max_f=fuzzy.function.PointFunc([(min_x[i],0),
                                    ((min_x[i]+max_x[i])/2.0,1.0),
                                    (max_x[i],0.0)])

    min_f=fuzzy.function.PointFunc([(min_x[i],1.0),
                                    ((min_x[i]+max_x[i])/2.0,0),
                                    (max_x[i],1.0)])
    x_functions.append(max_f)
    x_functions.append(min_f)

rules=[[]]

cur_rule=0
for i in numbers:
    for x in xrange(x_length):
        num=-1             
        max_value=-1       
        for f in xrange(len(x_functions)):
            cur_value=x_functions[f](data[i][x])
            if cur_value>max_value:
                max_value=cur_value
                num=f
        rules[cur_rule].append(x_functions[num])
    rules.append([])
    cur_rule+=1
print rules

\end{lstlisting}
%\textbf{mnk.py}
\begin{lstlisting}[language=python]
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy.linalg as linalg
import utils.data
import sys


data=utils.data.load_data(sys.argv[1])
result=linalg.lstsq(data[0],data[1])
print result
\end{lstlisting}
%\textbf{utils/__init__.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-
\end{lstlisting}
%\textbf{utils/data.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

import numpy

def load_data(path):
    data_file=file(path)
    data_x=[]
    data_y=[]
    for line in data_file.readlines():
        sline=line.strip()
        sl=sline.split(';')
        il=[]
        for s in sl[:-1]:
            s=s.strip()
            if s=='':
                continue
            il.append(float(s))
        if len(il)==0:
            continue
        data_x.append(il)
        data_y.append(float(sl[-1]))
    if len(data_y)!=len(data_x):
        raise "Error"
    return [numpy.array(data_x,dtype=float),numpy.array(data_y,dtype=float)]


if __name__=="__main__":
    import sys
    if len(sys.argv)!=2:
        print "usage",sys.argv[0],"path_to_file"
    print load_data(sys.argv[1])
    
\end{lstlisting}
%\textbf{fuzzy/myu_functions.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

import math

class exp:
    def __init__(self,c,q):
        self.c=c
        self.q=q

    def __call__(self,x):
        return math.exp(-0.5*((x-self.c)/self.q)**2)
\end{lstlisting}
%\textbf{fuzzy/function.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

from math import sqrt

class PointFunc:
    def __init__(self,data):
        self.data=data
        self.data.sort(cmp=lambda x,y: x[0]<y[0])

    def __call__(self,v):
        x=v.value if hasattr(v,"value") else v

        left=None
        right=None

        if x<self.data[0][0]: 
            return 0
        
        for i in range(len(self.data)-1):
            if self.data[i][0]==x:
                return self.data[i][1]
            if x>self.data[i][0] and x<self.data[i+1][0]:
                left=self.data[i]
                right=self.data[i+1]
                break

        if self.data[-1][0]==x:
            return self.data[-1][1]

        if left==right and left==None:
            if self.data[-1][1]==0:
                return 0
            else:
                return 1
        
        if (right[1]>left[1]):
            return  (((x-left[0])*(right[1]-left[1]))/(right[0]-left[1]))+left[1]
        else:
            return  ((left[1]-right[1])*(right[0]-x))/(right[0]-left[0])+right[1]

if __name__=="__main__":
    p=PointFunc([(1,0.25),(2,0.5),(3,1.0),(4,0.5),(5,0.25)])
    print "0.25 p(1)=",p(1)
    print "0.5  p(2)=",p(2)
    print "1.0  p(3)=",p(3)
    print "0.5  p(4)=",p(4)
    print "0.25 p(5)=",p(5)

    for i in [1.2,1.5,2.5,2.7,4.1,4.5]:
        print "p(",i,")=",p(i)

\end{lstlisting}
%\textbf{fuzzy/__init__.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-
\end{lstlisting}
%\textbf{fuzzy/sugeno.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

import numpy

def out(rules,x,y):
    """
    rules - [([f_x1,f_x2,...],y)]
    x - [[x_i]]
    y - [y_1,...,y_n]
    """
    myu=[]
    alphas=numpy.array(range(len(x)),dtype=float)
    y_1=numpy.array(y,dtype=float)
    for i in range(len(rules)):
        myu.append(numpy.array(range(len(rules[i][0])),dtype=float))
        for r in range(len(rules[i][0])):
            myu[i][r]=rules[i][0][r](x[i][r])
        alphas[i]=numpy.max(myu[i])
    return numpy.sum(alphas*y)/numpy.sum(alphas)
    

if __name__=="__main__":
    from fuzzy.myu_functions import exp
    x=[[1,2],[2,1]]
    y=[1,0]
    f1=exp(1,2)
    f2=exp(0.5,2.5)
    rules=[[[f1,f2],0.9],[[f2,f1],0.1]]
    print out(rules,x,y)
\end{lstlisting}
%\textbf{ga/population.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

import numpy

class Population:
    def __init__(self,crossover,mutator,pinit,selector,fitness,psize,is_elit=False):
        self.crv=crossover
        self.mtn=mutator
        self.pinit=pinit
        self.sel=selector
        self.ftn=fitness
        self.psize=psize
        self.is_elit=is_elit
        self.p=list((1,2))
        self.ftns=list((1,2))
        self.cur_p=0
        self.create()
    
    def create(self):
        self.p[0]=self.pinit(self.psize)
        self.p[1]=self.pinit(self.psize)
        self.ftns[0]=numpy.array(range(len(self.p[self.cur_p])),dtype=float)
        self.ftns[1]=numpy.array(range(len(self.p[self.cur_p])),dtype=float)
        other_p=(self.cur_p+1)%2
        for i in range(len(self.p[self.cur_p])):
            self.ftns[self.cur_p][i]=self.ftn(self.p[self.cur_p][i])
            self.ftns[other_p][i]=self.ftn(self.p[other_p][i])

    def best(self):
        best_ftn=self.ftns[self.cur_p][0]
        best_index=0
        for i in range(len(self.ftns[self.cur_p])):
            if self.ftns[self.cur_p][i]<best_ftn:
                best_ftn=self.ftns[self.cur_p][i]
                best_index=i
        return best_index

    def worst(self):
        worst_ftn=self.ftns[self.cur_p][0]
        worst_index=0
        for i in range(len(self.ftns[self.cur_p])):
            if self.ftns[self.cur_p][i]>worst_ftn:
                worst_ftn=self.ftns[self.cur_p][i]
                worst_index=i
        return worst_index

    def best_fitness(self):
        return self.ftns[self.cur_p][self.best()]

    def best_solution(self):
        return self.p[self.cur_p][self.best()]

    def oneStep(self):
        pairs=self.sel(self.p[self.cur_p])
        p_index=0
        other_p=(self.cur_p+1)%2
        for i in pairs:
            new_dna=self.crv(self.p[self.cur_p][i[0]],self.p[self.cur_p][i[1]])
            for d in new_dna:
                child=self.mtn(d)
                self.ftns[other_p][p_index]=self.ftn(child)
                self.p[other_p][p_index]=child
                p_index+=1

        if self.is_elit:
            bindex=self.best()
            self.cur_p=other_p
            windex=self.worst()
            self.p[self.cur_p][windex]=self.p[(self.cur_p+1)%2][bindex]
            self.ftns[self.cur_p][windex]=self.ftns[(self.cur_p+1)%2][bindex]
        else:
            self.cur_p=other_p

            
\end{lstlisting}
%\textbf{ga/__init__.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-
\end{lstlisting}
%\textbf{ga/std_mutator.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

import random

class Mutator:
    def __init__(self,delta,count,percent):
        self.delta=delta
        self.percent=percent
        self.count=count
        
    def __call__(self,d):
        if random.uniform(0.0,100.0)<=self.percent:
            indexes=[int(random.uniform(0.0,len(d))) for i in xrange(0,self.count)]
            result=d[:]
            for i in indexes:
                result[i]=result[i]+random.uniform(-self.delta,self.delta)
            return result
        else:
            return d
        
\end{lstlisting}
%\textbf{ga/std_ga.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

class GA:
    def __init__(self,population,stop_value,max_steps):
        self.population=population
        self.stop_value=stop_value
        self.max_steps=max_steps

    def run(self):
        for i in xrange(self.max_steps):
            self.population.oneStep()
            print "%d ==> "%(i),self.population.best_fitness()
            if self.population.best_fitness()<self.stop_value:
                break
\end{lstlisting}
%\textbf{ga/arithmetic_crv.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

import random

def crossover(f,m):
    alpha=random.uniform(0.0,1.0)
    k1=1.0-alpha
    child1=alpha*m+k1*f
    child2=alpha*f+k1*m
    return [child1,child2]
\end{lstlisting}
%\textbf{ga/std_selector.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

import random

class selector:
    def __init__(self,count):
        self.count=count
    
    def __call__(self,p):
        fathers=range(len(p))
        mathers=fathers[:]
        random.shuffle(fathers)
        random.shuffle(mathers)
        return map(None,fathers,mathers)[:self.count]
\end{lstlisting}
%\textbf{ga/population_init.py}
\begin{lstlisting}[language=python]
# -*- coding: utf-8 -*-

import numpy

class PopulationInit:
    def __init__(self,length,interval):
        self.length=length
        self._from=interval[0]
        self._to=interval[1]

    def __call__(self,size):
        result=numpy.random.uniform(self._from,self._to,(size,(self.length))) 
        return result

if __name__=="__main__":
    pinit=PopulationInit(5,3,(-10,10))
    a=pinit()
    print a
\end{lstlisting}

\end{document}
